1. Field of the Invention
This invention relates to an event-driven data processing software system having multiple software modules for processing data in communication with one another. More particularly, this invention relates to a software system having a task module that executes self-modifying scripts, thereby invoking active responses from data processing modules based upon event data that is transmitted to the task module from other modules.
2. Brief Description of the Background
Conventional methodology for accessing network application data can be cumbersome. For example, in order for a client/user to access data from a network application, it is typically necessary for the network application and the application protocol to be modified to enable the client/user protocol to recognize them. This modification is inefficient because it necessitates the conversion of server application programs to another protocol in order to access data desired by the client. In other words, the network application and the client/user may not be able to communicate with each other because of different native applications or protocols.
A second example of the cumbersome nature of conventional network interactions is illustrated by the fact that network applications and data are typically not dynamically updated based upon sequential or simultaneous activities or events that are taking place in other network applications.
There have been attempts to address some of these inefficiencies and shortcomings. Unfortunately, as can be seen from the following discussion, these attempts fail to provide a means for dynamically processing data from a variety of network applications.
U.S. Pat. No. 5,325,527 (Cwikowski et al.) discloses a client/server communications system utilizing a self-generating nodal network. Each service node includes both process steps for advertising a service to the server root node and process steps for building a topic node which includes both process steps for accessing a server and process steps for building a job node in order to store job requests. The service nodes include steps for communicating with an application program and steps to create a job request in accordance with a job request designated by the application program. However, the Cwikowski et al. patent fails to recognize the need for a system that receives data and utilizes self-modifying commands to gather additional data from a plurality of processors in order to “update” itself or to incorporate the additional data, much less to disclose a system that addresses such needs.
U.S. Pat. No. 5,325,530 (Mohrmann) discloses a controller for sequential programming tools executed in a parallel-computing environment. This controller executes sequential tools on an individual node of a parallel computing system. The controller associates each tool with a particular process of a user program executing on a particular node. In particular, the controller, in combination with various debugging tools operating on various nodes in the parallel-computing environment, produces a parallel program debugger. Unfortunately, the invention disclosed in the Mohrmann patent merely performs steps sequentially, and does not disclose a system that dynamically modifies steps that have yet to be performed.
U.S. Pat. No. 5,625,837 (Popescu et al.) discloses a processor architecture having out-of-order execution, and speculative branching capabilities that give priority to instructions that affect a condition code. This process architecture uses instruction fetching functions that are decoupled from instruction execution functions by a dynamic register file. More specifically, the results of the executed instructions are flushed from provisional storage, and the instruction previously executed at the beginning of a branch based upon predicted dependencies is re-executed based upon the actual data that subsequently becomes available. However, the Popescu et al. patent fails to disclose gathering processed data from a network, much less a system that dynamically incorporates the gathered processed data in order to “learn” from it.
U.S. Pat. No. 5,634,127 (Cloud et al.) discloses methods and apparatus for implementing a message driven processor in a client-server environment. This message driven processor operates as middleware between clients and back-end hosts or servers in a large client-server system to reduce the number of concurrent sessions required to be supported by the network and to allow a common client-user interface to divergent back-end systems. The Cloud et al. patent teaches a message queue for storing data but does not disclose mapping a message to a set of commands that is self-modifying, much less a system that incorporates gathered data into the system.
U.S. Pat. No. 5,689,708 (Regnier et al.) discloses a client/server computer-system that controls a) client-based application programs and b) application-programs. A resource manager and a client/server computer network control the availability of system resources. A system administrator generates a set of profiles that specifies which system resources each user may employ for each of multiple application programs. The Regnier et al. patent discloses resource management, but does not disclose that the resource management capabilities interact with multiple databases to gather processed data for use in the system.
As can be seen from the illustrative background discussed above, there is a need in the computer-programming field for a data processing system that 1) has the capability to receive requests from a variety of applications, which operate in a variety of environments, and 2) provides an appropriate response. The present invention provides a solution to that need in the form of an event-driven data processing system that utilizes series of self-modifying commands to receive event data signals and to generate an appropriate response, and updates the self-modifying commands in response to the event data.